home *** CD-ROM | disk | FTP | other *** search
/ Aminet 40 / Aminet 40 (2000)(Schatztruhe)[!][Dec 2000].iso / Aminet / misc / emu / ATUtilities.lha / ATUtilities / Schoner.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-09-26  |  15.2 KB  |  730 lines
  1. /* ******************************************************************* */
  2. /* **                                                               ** */
  3. /* **                     ATKeyboard Version 4.0                    ** */
  4. /* **            Copright (C) 1992-1994 by Thomas Dreibholz         ** */
  5. /* **                      All rights reserved                      ** */
  6. /* **                                                               ** */
  7. /* **                       Schoner-Steuerung                       ** */
  8. /* **                                                               ** */
  9. /* ******************************************************************* */
  10.  
  11. #include "ATkeyboard.h"
  12.  
  13. extern struct Window        *WindowPtr;
  14. extern struct TextFont      *SchonerFont;
  15. extern struct Help          *Help;
  16. extern struct Screen        *SchonerScreen;
  17. extern struct Window        *SchonerWindow;
  18. extern struct RastPort      *SchonerRastPort;
  19. extern struct ViewPort      *SchonerViewPort;
  20. extern struct Task          *SchonerTask;
  21. extern struct Task          *ColorCyclingTask;
  22. extern struct MsgPort       *Port1,*Port2,*Port3;
  23. extern struct Message       *Message1,*Message2;
  24. extern struct Einstellungen  Einstellungen;
  25. extern struct NewScreen      SchonerScreenDef;
  26. extern struct NewWindow      SchonerWindowDef;
  27. extern struct Image          MouseImage;
  28.  
  29. EXTERN UBYTE *Buffer;
  30. EXTERN BOOL   Online;
  31. EXTERN BOOL   Schoner;
  32.  
  33. EXTERN UWORD SchonerPalette[];
  34.  
  35. VOID Ausgabe();
  36. VOID TesteEnde();
  37. VOID Warte();
  38. VOID SchonerProc();
  39. VOID ColorCyclingProc();
  40. VOID KontrolliereSchoner();
  41. VOID XMove();
  42. VOID XDraw();
  43. VOID XWritePixel();
  44. WORD Zufall();
  45. WORD rand();
  46.  
  47.  
  48. /* Warten, bis Grafik gewechselt werden muß */
  49. VOID Warte()
  50. {
  51.  REGISTER UWORD a;
  52.  
  53.  ScreenToFront(SchonerScreen);
  54.  for(a=0;a<Einstellungen.GrafikGeschwindigkeit;a++)
  55.   {
  56.    TesteEnde();
  57.    Delay(50);
  58.    ScreenToFront(SchonerScreen);
  59.   }
  60.  XMove(1,1);
  61.  ClearScreen(SchonerRastPort);
  62. }
  63.  
  64.  
  65. /* Testen, ob Schoner beendet werden soll */
  66. VOID TesteEnde()
  67. {
  68.  register struct Message *Message;
  69.  
  70.  Message=GetMsg(Port1);
  71.  if(Message!=NULL)
  72.   {
  73.    CloseWindow(SchonerWindow);
  74.    CloseScreen(SchonerScreen);
  75.    SchonerScreen=NULL;
  76.    ReplyMsg(Message);
  77.    Exit(0);
  78.   }
  79. }
  80.  
  81.  
  82. /* Bildschirmschoner-Task */
  83. #define ANZ_STERNE 100
  84.  
  85. VOID SchonerProc()
  86. {
  87.  REGISTER WORD  a,i,rx,ry,co1,co2;
  88.  REGISTER ULONG fa,x,fp0,fp1,fp2;
  89.  REGISTER LONG  m,n;
  90.  ULONG          f025,f0,f1,f3,f02,f56,f0125,f008,f004,f006,f007;
  91.  UWORD          ArrayX[ANZ_STERNE],ArrayY[ANZ_STERNE];
  92.  
  93.  geta4();
  94.  if(Einstellungen.FarbrollPrioritaet<Einstellungen.SchonerPrioritaet)
  95.   {
  96.    Delay(25); /* Auf Farbroll-Task warten ... */
  97.   }
  98.  f025=XDiv(XFlt(40),XFlt(1));
  99.  f0=XFlt(0);
  100.  f1=XFlt(1);
  101.  f3=XFlt(3);
  102.  f56=XFlt(56);
  103.  f02=XDiv(XFlt(50),XFlt(1));
  104.  f0125=XDiv(XFlt(2),f025);
  105.  f008=XDiv(XFlt(100),XFlt(8));
  106.  f007=XDiv(XFlt(100),XFlt(7));
  107.  f006=XDiv(XFlt(100),XFlt(6));
  108.  f004=XDiv(XFlt(100),XFlt(4));
  109.  FOREVER
  110.   {
  111.    if(Einstellungen.Gfx[0])
  112.     {
  113.      for(a=10;a<110;a+=7)
  114.       {
  115.        TesteEnde();
  116.        rx=1;
  117.        ry=125;
  118.        co1=3;
  119.        x=f0;
  120.        fa=XFlt(a);
  121.        XMove(rx,ry);
  122.        while(rx<318)
  123.         {
  124.          SetAPen(SchonerRastPort,co1);
  125.          XDraw(rx,ry+XFix(XMul(fa,XSin(x))));
  126.          x=XAdd(x,f025);
  127.          co1++;
  128.          if(co1>31) co1=3;
  129.          rx++;
  130.         }
  131.        rx=1;
  132.        ry=125;
  133.        co2=32;
  134.        x=f0;
  135.        fa=XFlt(a);
  136.        XMove(rx,ry+XFix(XMul(XFlt(a),XCos(f0))));
  137.        while(rx<318)
  138.         {
  139.          SetAPen(SchonerRastPort,co2);
  140.          XDraw(rx,ry+XFix(XMul(fa,XCos(x))));
  141.          x=XAdd(x,f025);
  142.          co2++;
  143.          if(co2>63) co2=32;
  144.          rx++;
  145.         }
  146.       }
  147.      Warte();
  148.     }
  149.    if(Einstellungen.Gfx[1])
  150.     {
  151.      for(a=10;a<110;a+=7)
  152.       {
  153.        TesteEnde();
  154.        rx=1;
  155.        ry=125;
  156.        co1=3;
  157.        x=f0;
  158.        fa=XFlt(a);
  159.        XMove(rx,ry);
  160.        while(rx<318)
  161.         {
  162.          SetAPen(SchonerRastPort,co1);
  163.          XDraw(rx,ry+XFix(XMul(fa,XSin(x))));
  164.          x=XAdd(x,f025);
  165.          co1++;
  166.          if(co1>31) co1=3;
  167.          rx++;
  168.         }
  169.       }
  170.      Warte();
  171.     }
  172.    if(Einstellungen.Gfx[2])
  173.     {
  174.      for(a=10;a<110;a+=7)
  175.       {
  176.        TesteEnde();
  177.        rx=1;
  178.        ry=125;
  179.        co2=3;
  180.        x=f0;
  181.        fa=XFlt(a);
  182.        XMove(rx,ry+XFix(XMul(XFlt(a),XCos(f0))));
  183.        while(rx<318)
  184.         {
  185.          SetAPen(SchonerRastPort,co2);
  186.          XDraw(rx,ry+XFix(XMul(fa,XCos(x))));
  187.          x=XAdd(x,f025);
  188.          co2++;
  189.          if(co2>31) co2=3;
  190.          rx++;
  191.         }
  192.       }
  193.      Warte();
  194.     }
  195.    if(Einstellungen.Gfx[3])
  196.     {
  197.      for(a=10;a<110;a+=7)
  198.       {
  199.        TesteEnde();
  200.        rx=1;
  201.        ry=80;
  202.        co1=3;
  203.        x=f0;
  204.        fa=XFlt(a);
  205.        XMove(rx,ry);
  206.        while(rx<318)
  207.         {
  208.          SetAPen(SchonerRastPort,co1);
  209.          fp0=XMul(XSin(x),XCos(x));
  210.          XDraw(rx,ry+XFix(XMul(fa,XMul(fp0,XTan(x)))));
  211.          x=XAdd(x,f025);
  212.          co1++;
  213.          if(co1>31) co1=3;
  214.          rx++;
  215.         }
  216.       }
  217.      Warte();
  218.     }
  219.    if(Einstellungen.Gfx[4])
  220.     {
  221.      for(a=10;a<110;a+=7)
  222.       {
  223.        TesteEnde();
  224.        rx=1;
  225.        ry=70;
  226.        co1=3;
  227.        x=f0;
  228.        fa=XFlt(a);
  229.        XMove(rx,ry);
  230.        while(rx<318)
  231.         {
  232.          SetAPen(SchonerRastPort,co1);
  233.          fp0=XMul(XSin(x),XCos(x));
  234.          fp1=XMul(XTan(x),XAtan(x));
  235.          XDraw(rx,ry+XFix(XMul(fa,XMul(fp0,fp1))));
  236.          x=XAdd(x,f025);
  237.          co1++;
  238.          if(co1>31) co1=3;
  239.          rx++;
  240.         }
  241.       }
  242.      Warte();
  243.     }
  244.    if(Einstellungen.Gfx[5])
  245.     {
  246.      for(a=10;a<90;a+=7)
  247.       {
  248.        TesteEnde();
  249.        rx=1;
  250.        ry=125;
  251.        co1=3;
  252.        x=f0;
  253.        fa=XFlt(a);
  254.        XMove(rx,ry);
  255.        while(rx<318)
  256.         {
  257.          SetAPen(SchonerRastPort,co1);
  258.          XDraw(rx,ry+XFix(XMul(fa,XMul(XAtan(x),XCos(x)))));
  259.          x=XAdd(x,f025);
  260.          co1++;
  261.          if(co1>31) co1=3;
  262.          rx++;
  263.         }
  264.       }
  265.      Warte();
  266.     }
  267.    if(Einstellungen.Gfx[6])
  268.     {
  269.      for(a=10;a<80;a+=7)
  270.       {
  271.        x=f0;
  272.        TesteEnde();
  273.        rx=1;
  274.        ry=125;
  275.        co1=3;
  276.        fa=XFlt(a);
  277.        fp0=XSqrt(XMul(x,x));
  278.        XMove(rx,ry+XFix(XMul(fa,XMul(XAtan(fp0),XSin(fp0)))));
  279.        while(rx<318)
  280.         {
  281.          fp0=XSqrt(XMul(x,x));
  282.          SetAPen(SchonerRastPort,co1);
  283.          XDraw(rx,ry+XFix(XMul(fa,XMul(XAtan(fp0),XSin(fp0)))));
  284.          x=XAdd(x,f025);
  285.          co1++;
  286.          if(co1>31) co1=3;
  287.          rx++;
  288.         }
  289.       }
  290.      Warte();
  291.     }
  292.    if(Einstellungen.Gfx[7])
  293.     {
  294.      for(a=10;a<90;a+=7)
  295.       {
  296.        TesteEnde();
  297.        rx=1;
  298.        ry=125;
  299.        co1=3;
  300.        x=f0;
  301.        fa=XFlt(a);
  302.        XMove(rx,ry);
  303.        while(rx<318)
  304.         {
  305.          SetAPen(SchonerRastPort,co1);
  306.          fp0=XCos(XMul(x,x));
  307.          fp1=XAtan(XSqrt(x));
  308.          XDraw(rx,ry+XFix(XMul(fa,XMul(fp0,fp1))));
  309.          x=XAdd(x,f02);
  310.          co1++;
  311.          if(co1>31) co1=3;
  312.          rx++;
  313.         }
  314.       }
  315.      Warte();
  316.     }
  317.    if(Einstellungen.Gfx[8])
  318.     {
  319.      for(a=10;a<90;a+=7)
  320.       {
  321.        TesteEnde();
  322.        rx=1;
  323.        ry=190;
  324.        co1=3;
  325.        x=f0;
  326.        fa=XFlt(a);
  327.        XMove(rx,ry);
  328.        while(rx<318)
  329.         {
  330.          SetAPen(SchonerRastPort,co1);
  331.          fp0=XMul(x,x);
  332.          fp1=XMul(XTan(x),XTan(x));
  333.          fp2=XSqrt(XSqrt(XSqrt(fp1)));
  334.          fp1=XMul(XSin(fp0),XCos(fp0));
  335.          XDraw(rx,ry+XFix(XMul(fa,XMul(fp1,fp2))));
  336.          x=XAdd(x,f0125);
  337.          co1++;
  338.          if(co1>31) co1=3;
  339.          rx++;
  340.         }
  341.       }
  342.      Warte();
  343.     }
  344.    if(Einstellungen.Gfx[9])
  345.     {
  346.      x=f0;
  347.      for(a=10;a<50;a+=3)
  348.       {
  349.        TesteEnde();
  350.        rx=1;
  351.        ry=120;
  352.        co1=3;
  353.        fa=XFlt(a);
  354.        fp0=XMul(fa,XSin(x));
  355.        fp1=XSin(fp0);
  356.        XMove(rx-XFix(fp1),ry+XFix(fp0));
  357.        while(rx<318)
  358.         {
  359.          SetAPen(SchonerRastPort,co1);
  360.          fp0=XMul(fa,XSin(x));
  361.          fp1=XAbs(XSin(fp0));
  362.          XDraw(rx-XFix(fp1),ry+XFix(fp0));
  363.          x=XAdd(x,f004);
  364.          co1++;
  365.          if(co1>31) co1=3;
  366.          rx++;
  367.         }
  368.        x=XAdd(x,f008);
  369.       }
  370.      Warte();
  371.     }
  372.    if(Einstellungen.Gfx[10])
  373.     {
  374.      x=f0;
  375.      for(a=10;a<55;a+=3)
  376.       {
  377.        TesteEnde();
  378.        rx=1;
  379.        ry=120;
  380.        co1=3;
  381.        fa=XFlt(a);
  382.        fp0=XMul(fa,XCos(x));
  383.        fp1=XMul(XAtan(fp0),f3);
  384.        XMove(rx-XFix(fp1),ry+XFix(fp0));
  385.        while(rx<318)
  386.         {
  387.          SetAPen(SchonerRastPort,co1);
  388.          fp0=XMul(fa,XCos(x));
  389.          fp1=XMul(XAtan(fp0),f3);
  390.          XDraw(rx-XFix(fp1),ry+XFix(fp0));
  391.          x=XAdd(x,f004);
  392.          co1++;
  393.          if(co1>31) co1=3;
  394.          rx++;
  395.         }
  396.        x=XAdd(x,f007);
  397.       }
  398.      Warte();
  399.     }
  400.    if(Einstellungen.Gfx[11])
  401.     {
  402.      for(a=10;a<50;a+=3)
  403.       {
  404.        TesteEnde();
  405.        rx=1;
  406.        ry=120;
  407.        co1=3;
  408.        x=f0;
  409.        fa=XFlt(a);
  410.        fp0=XMul(fa,XCos(x));
  411.        fp1=XMul(XAtan(fp0),XMul(XSin(fp0),XCos(fp0)));
  412.        XMove(rx-XFix(fp1),ry+XFix(fp0));
  413.        while(rx<318)
  414.         {
  415.          SetAPen(SchonerRastPort,co1);
  416.          fp0=XMul(fa,XCos(x));
  417.          fp1=XMul(XAtan(fp0),XMul(XSin(fp0),XCos(fp0)));
  418.          XDraw(rx-XFix(fp1),ry+XFix(fp0));
  419.          x=XAdd(x,f006);
  420.          co1++;
  421.          if(co1>31) co1=3;
  422.          rx++;
  423.         }
  424.       }
  425.      Warte();
  426.     }
  427.    if(Einstellungen.Gfx[12])
  428.     {
  429.      for(a=10;a<100;a+=5)
  430.       {
  431.        TesteEnde();
  432.        rx=1;
  433.        ry=120;
  434.        co1=32;
  435.        x=XDiv(f56,XFlt(a-10));
  436.        fa=XFlt(a);
  437.        XMove(rx,ry+XFix(XMul(fa,XCos(x))));
  438.        while(rx<318)
  439.         {
  440.          SetAPen(SchonerRastPort,co1);
  441.          XDraw(rx,ry+XFix(XMul(fa,XCos(x))));
  442.          x=XAdd(x,f025);
  443.          co1++;
  444.          if(co1>31) co1=3;
  445.          rx++;
  446.         }
  447.       }
  448.      Warte();
  449.     }
  450.    if(Einstellungen.Gfx[13])
  451.     {
  452.      for(a=10;a<100;a+=5)
  453.       {
  454.        TesteEnde();
  455.        rx=1;
  456.        ry=120;
  457.        co1=32;
  458.        x=XDiv(f56,XFlt(a-10));
  459.        fa=XFlt(a);
  460.        XMove(rx,ry+XFix(XMul(fa,XCos(x))));
  461.        while(rx<318)
  462.         {
  463.          SetAPen(SchonerRastPort,co1);
  464.          XDraw(rx,ry+XFix(XMul(fa,XCos(x))));
  465.          x=XAdd(x,f025);
  466.          co1++;
  467.          if(co1>63) co1=32;
  468.          rx++;
  469.         }
  470.        TesteEnde();
  471.        rx=1;
  472.        ry=120;
  473.        co1=3;
  474.        x=XDiv(f56,XFlt(a-10));
  475.        fa=XFlt(a);
  476.        XMove(rx,ry+XFix(XMul(fa,XSin(x))));
  477.        while(rx<318)
  478.         {
  479.          SetAPen(SchonerRastPort,co1);
  480.          XDraw(rx,ry+XFix(XMul(fa,XSin(x))));
  481.          x=XAdd(x,f025);
  482.          co1++;
  483.          if(co1>31) co1=3;
  484.          rx++;
  485.         }
  486.       }
  487.      Warte();
  488.     }
  489.    if(Einstellungen.Gfx[14])
  490.     {
  491.      co1=3;
  492.      for(i=0;i<ANZ_STERNE;i++)
  493.       {
  494.        ArrayX[i]=Zufall(1,319);
  495.        ArrayY[i]=Zufall(1,255);
  496.        SetAPen(SchonerRastPort,co1);
  497.        XWritePixel(ArrayX[i],ArrayY[i]);
  498.        co1++;
  499.        if(co1>63) co1=3;
  500.       }
  501.      m=0; n=(Einstellungen.GrafikGeschwindigkeit*50)/ANZ_STERNE;
  502.      while(m<n)
  503.       {
  504.        for(i=0;i<ANZ_STERNE;i++)
  505.         {
  506.          SetAPen(SchonerRastPort,0);
  507.          XWritePixel(ArrayX[i],ArrayY[i]);
  508.          SetAPen(SchonerRastPort,co1);
  509.          ArrayX[i]=Zufall(1,319);
  510.          ArrayY[i]=Zufall(1,255);
  511.          XWritePixel(ArrayX[i],ArrayY[i]);
  512.          Delay(3);
  513.          TesteEnde();
  514.          co1++;
  515.          if(co1>63) co1=3;
  516.         }
  517.        m++;
  518.       }
  519.      XMove(1,1);
  520.      ClearScreen(SchonerRastPort);
  521.     }
  522.    if(Einstellungen.Gfx[15])
  523.     {
  524.      Ausgabe(Copyright[0],80,3);
  525.      Ausgabe(Copyright[1],110,3);
  526.      Ausgabe(Copyright[2],140,10);
  527.      Ausgabe(Copyright[3],170,5);
  528.      Warte();
  529.     }
  530.   }
  531. }
  532.  
  533.  
  534. /* Text zentriert und leicht verzögert ausgeben */
  535. VOID Ausgabe(text,y,farbe)
  536.  UBYTE *text;
  537.  WORD   y;
  538.  UBYTE  farbe;
  539. {
  540.  REGISTER WORD laenge,x,i;
  541.  REGISTER BOOL ende;
  542.  UBYTE         wort[2];
  543.  
  544.  laenge=strlen(text);
  545.  x=(320-TextLength(SchonerRastPort,text,laenge))/2;
  546.  XMove(x,y);
  547.  for(i=0;i<laenge;i++)
  548.   {
  549.    wort[0]=text[i];
  550.    SetAPen(SchonerRastPort,farbe);
  551.    Text(SchonerRastPort,&wort,1L);
  552.    x+=TextLength(SchonerRastPort,&wort,1L);
  553.    XMove(x,y);
  554.    farbe++;
  555.    if(farbe>63) farbe=3;
  556.    Delay(7);
  557.    TesteEnde();
  558.   }
  559. }
  560.  
  561.  
  562. /* Colorcycling-Task */
  563. VOID ColorCyclingProc()
  564. {
  565.  REGISTER WORD            i,help;
  566.  register struct Message *Message;
  567.  
  568.  geta4();
  569.  FOREVER
  570.   {
  571.    Message=GetMsg(Port2);
  572.    if(Message!=NULL)
  573.     {
  574.      ReplyMsg(Message);
  575.      return;
  576.     }
  577.    LoadRGB4(SchonerViewPort,&SchonerPalette,32L);
  578.    help=SchonerPalette[31];
  579.    for(i=31;i>3;i--) SchonerPalette[i]=SchonerPalette[i-1];
  580.    SchonerPalette[3]=help;
  581.    Delay(Einstellungen.FarbrollGeschwindigkeit);
  582.   }
  583. }
  584.  
  585.  
  586. /* Prüfen, ob Schoner ein- oder ausgeschaltet werden muß */
  587. UBYTE *SchonerTaskName="ATKeyboard Schoner Task";
  588. UBYTE *ColorCyclingTaskName="ATKeyboard Color Cycling Task";
  589.  
  590. VOID KontrolliereSchoner()
  591. {
  592.  if((Schoner==TRUE)&&(SchonerScreen==NULL))
  593.   {
  594.    if(Einstellungen.SystemPAL==YES)
  595.     {
  596.      SchonerScreenDef.Height=256;
  597.      SchonerWindowDef.Height=256;
  598.     }
  599.    else
  600.     {
  601.      SchonerScreenDef.Height=200;
  602.      SchonerWindowDef.Height=200;
  603.     }
  604.    SchonerScreen=OpenScreen(&SchonerScreenDef);
  605.    if(SchonerScreen!=NULL)
  606.     {
  607.      SchonerWindowDef.Screen=SchonerScreen;
  608.      SchonerWindow=OpenWindow(&SchonerWindowDef);
  609.      if(SchonerWindow!=NULL)
  610.       {
  611.        LeerePort(Port1);
  612.        LeerePort(Port2);
  613.        LeerePort(Port3);
  614.        SchonerRastPort=SchonerWindow->RPort;
  615.        SchonerViewPort=ViewPortAddress(SchonerWindow);
  616.        if(SchonerFont) SetFont(SchonerRastPort,SchonerFont);
  617.        SchonerTask=CreateProcess(SchonerProc,6500,SchonerTaskName,Einstellungen.SchonerPrioritaet);
  618.        if(SchonerTask==NULL)
  619.         {
  620.          CloseWindow(SchonerWindow);
  621.          CloseScreen(SchonerScreen);
  622.          SchonerScreen=NULL;
  623.          Schoner=FALSE;
  624.          return;
  625.         }
  626.        ColorCyclingTask=CreateProcess(ColorCyclingProc,2500,ColorCyclingTaskName,Einstellungen.FarbrollPrioritaet);
  627.        if(ColorCyclingTask==NULL)
  628.         {
  629.          PutMsg(Port1,Message1);
  630.          WaitPort(Port3);
  631.          GetMsg(Port3);
  632.          SchonerScreen=NULL;
  633.          Schoner=FALSE;
  634.          return;
  635.         }
  636.        if(Einstellungen.Maus)
  637.         {
  638.          SetPointer(WindowPtr,&MouseImage,1,1,0,0);
  639.          SetPointer(SchonerWindow,&MouseImage,1,1,0,0);
  640.         }
  641.        Say("the screen blanker is turned on");
  642.       }
  643.      else
  644.       {
  645.        CloseScreen(SchonerScreen);
  646.        SchonerScreen=NULL;
  647.        Schoner=FALSE;
  648.        return;
  649.       }
  650.     }
  651.    else
  652.     {
  653.      Schoner=FALSE;
  654.     }
  655.   }
  656.  if((Schoner==FALSE)&&(SchonerScreen!=NULL))
  657.   {
  658.    ScreenToBack(SchonerScreen);
  659.    ClearPointer(WindowPtr);
  660.    PutMsg(Port2,Message2);
  661.    WaitPort(Port3);
  662.    GetMsg(Port3);
  663.    PutMsg(Port1,Message1);
  664.    WaitPort(Port3);
  665.    GetMsg(Port3);
  666.    Say("the screen blanker is turned off");
  667.    Delay(30);
  668.   }
  669. }
  670.  
  671.  
  672. /* Zufallszahl im Bereich min bis max zurückgeben */
  673. WORD Zufall(min,max)
  674.  WORD min,max;
  675. {
  676.  REGISTER WORD x;
  677.  
  678.  x=rand();
  679.  x=(x % (max-min))+min;
  680. }
  681.  
  682.  
  683. /* Move-Befehl mit PAL/NTSC-Umrechnung */
  684. VOID XMove(x,y)
  685.  UWORD x,y;
  686. {
  687.  
  688.  if(SchonerScreen->Height!=256)
  689.   {
  690.    Move(SchonerRastPort,x,(y*200)/256);
  691.   }
  692.  else
  693.   {
  694.    Move(SchonerRastPort,x,y);
  695.   }
  696. }
  697.  
  698.  
  699. /* Draw-Befehl mit PAL/NTSC-Umrechnung */
  700. VOID XDraw(x,y)
  701.  UWORD x,y;
  702. {
  703.  
  704.  if(SchonerScreen->Height!=256)
  705.   {
  706.    Draw(SchonerRastPort,x,(y*200)/256);
  707.   }
  708.  else
  709.   {
  710.    Draw(SchonerRastPort,x,y);
  711.   }
  712. }
  713.  
  714.  
  715. /* WritePixel-Befehl mit PAL/NTSC-Umrechnung */
  716. VOID XWritePixel(x,y)
  717.  UWORD x,y;
  718. {
  719.  
  720.  if(SchonerScreen->Height!=256)
  721.   {
  722.    WritePixel(SchonerRastPort,x,(y*200)/256);
  723.   }
  724.  else
  725.   {
  726.    WritePixel(SchonerRastPort,x,y);
  727.   }
  728. }
  729.  
  730.